home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 4 / QRZ Ham Radio Callsign Database - Volume 4.iso / files / dsp / 56ktools / dspkgctr.z / dspkgctr / gcc / gcc.c < prev    next >
C/C++ Source or Header  |  1992-06-08  |  68KB  |  2,740 lines
  1. /* Compiler driver program that can handle many languages.
  2.    Copyright (C) 1987,1989 Free Software Foundation, Inc.
  3.  
  4.    $Id: gcc.c,v 1.43 92/04/01 18:28:28 pete Exp $
  5.  
  6. This file is part of GNU CC.
  7.  
  8. GNU CC is free software; you can redistribute it and/or modify
  9. it under the terms of the GNU General Public License as published by
  10. the Free Software Foundation; either version 1, or (at your option)
  11. any later version.
  12.  
  13. GNU CC is distributed in the hope that it will be useful,
  14. but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. GNU General Public License for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with GNU CC; see the file COPYING.  If not, write to
  20. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  
  22. This paragraph is here to try to keep Sun CC from dying.
  23. The number of chars here seems crucial!!!!  */
  24.  
  25. void record_temp_file ();
  26.  
  27. /* This program is the user interface to the C compiler and possibly to
  28. other compilers.  It is used because compilation is a complicated procedure
  29. which involves running several programs and passing temporary files between
  30. them, forwarding the users switches to those programs selectively,
  31. and deleting the temporary files at the end.
  32.  
  33. CC recognizes how to compile each input file by suffixes in the file names.
  34. Once it knows which kind of compilation to perform, the procedure for
  35. compilation is specified by a string called a "spec".
  36.  
  37. Specs are strings containing lines, each of which (if not blank)
  38. is made up of a program name, and arguments separated by spaces.
  39. The program name must be exact and start from root, since no path
  40. is searched and it is unreliable to depend on the current working directory.
  41. Redirection of input or output is not supported; the subprograms must
  42. accept filenames saying what files to read and write.
  43.  
  44. In addition, the specs can contain %-sequences to substitute variable text
  45. or for conditional text.  Here is a table of all defined %-sequences.
  46. Note that spaces are not generated automatically around the results of
  47. expanding these sequences; therefore, you can concatenate them together
  48. or with constant text in a single argument.
  49.  
  50.  %%    substitute one % into the program name or argument.
  51.  %i     substitute the name of the input file being processed.
  52.  %b     substitute the basename of the input file being processed.
  53.     This is the substring up to (and not including) the last period.
  54.  %g     substitute the temporary-file-name-base.  This is a string chosen
  55.     once per compilation.  Different temporary file names are made by
  56.     concatenation of constant strings on the end, as in `%g.s'.
  57.     %g also has the same effect of %d.
  58.  
  59. ****** DSP56000/DSP96000 EXTENSION ******
  60.  %z    substitute the argument of the current flag. usefull for renaming 
  61.     flags. example: on the DSP*6000 there is no "-o filename" flag. We
  62.     must generate a command sequence of the form "-B filename" in order
  63.     to perform this we need to get at "part2" of switches[*].
  64.     %{o*:-B %zo --}    <--- this does the trick
  65.  
  66.  %d    marks the argument containing or following the %d as a
  67.     temporary file name, so that that file will be deleted if CC exits
  68.     successfully.  Unlike %g, this contributes no text to the argument.
  69.  %w    marks the argument containing or following the %w as the
  70.     "output file" of this compilation.  This puts the argument
  71.     into the sequence of arguments that %o will substitute later.
  72.  %o    substitutes the names of all the output files, with spaces
  73.     automatically placed around them.  You should write spaces
  74.     around the %o as well or the results are undefined.
  75.     %o is for use in the specs for running the linker.
  76.     Input files whose names have no recognized suffix are not compiled
  77.     at all, but they are included among the output files, so they will
  78.     be linked.
  79.  %p    substitutes the standard macro predefinitions for the
  80.     current target machine.  Use this when running cpp.
  81.  %P    like %p, but puts `__' before and after the name of each macro.
  82.     This is for ANSI C.
  83.  %s     current argument is the name of a library or startup file of some sort.
  84.         Search for that file in a standard list of directories
  85.     and substitute the full pathname found.
  86.  %eSTR  Print STR as an error message.  STR is terminated by a newline.
  87.         Use this when inconsistent options are detected.
  88.  %a     process ASM_SPEC as a spec.
  89.         This allows config.h to specify part of the spec for running as.
  90.  %l     process LINK_SPEC as a spec.
  91.  %L     process LIB_SPEC as a spec.
  92.  %S     process STARTFILE_SPEC as a spec.  A capital S is actually used here.
  93.  %c    process SIGNED_CHAR_SPEC as a spec.
  94.  %C     process CPP_SPEC as a spec.  A capital C is actually used here.
  95.  %1    process CC1_SPEC as a spec.
  96.  %{S}   substitutes the -S switch, if that switch was given to CC.
  97.     If that switch was not specified, this substitutes nothing.
  98.     Here S is a metasyntactic variable.
  99.  %{S*}  substitutes all the switches specified to CC whose names start
  100.     with -S.  This is used for -o, -D, -I, etc; switches that take
  101.     arguments.  CC considers `-o foo' as being one switch whose
  102.     name starts with `o'.  %{o*} would substitute this text,
  103.     including the space; thus, two arguments would be generated.
  104.  %{S:X} substitutes X, but only if the -S switch was given to CC.
  105.  %{!S:X} substitutes X, but only if the -S switch was NOT given to CC.
  106.  %{|S:X} like %{S:X}, but if no S switch, substitute `-'.
  107.  %{|!S:X} like %{!S:X}, but if there is an S switch, substitute `-'.
  108.  
  109. The conditional text X in a %{S:X} or %{!S:X} construct may contain
  110. other nested % constructs or spaces, or even newlines.
  111. They are processed as usual, as described above.
  112.  
  113. The character | is used to indicate that a command should be piped to
  114. the following command, but only if -pipe is specified.
  115.  
  116. Note that it is built into CC which switches take arguments and which
  117. do not.  You might think it would be useful to generalize this to
  118. allow each compiler's spec to say which switches take arguments.  But
  119. this cannot be done in a consistent fashion.  CC cannot even decide
  120. which input files have been specified without knowing which switches
  121. take arguments, and it must know which input files to compile in order
  122. to tell which compilers to run.
  123.  
  124. CC also knows implicitly that arguments starting in `-l' are to
  125. be treated as compiler output files, and passed to the linker in their proper
  126. position among the other output files.
  127.  
  128. */
  129.  
  130. #include <stdio.h>
  131. #include <sys/types.h>
  132. #include <signal.h>
  133. #include <string.h>
  134.  
  135. #if ! defined( _MSDOS )
  136. #include <sys/file.h>
  137. #if ! defined( sun )
  138. #include <stdlib.h>
  139. #endif
  140. #endif  /* ! _MSDOS */
  141.  
  142. #include "config.h"
  143. #include "obstack.h"
  144. #ifdef __TURBOC__
  145. #include <stdarg.h>
  146. #else
  147. #include "gvarargs.h"
  148. #endif
  149.  
  150. #if defined( _MSDOS )
  151. #include <process.h>
  152. #define R_OK 4
  153. #define W_OK 2
  154. #define X_OK 1
  155. #endif
  156.  
  157. #ifdef USG
  158. #define R_OK 4
  159. #define W_OK 2
  160. #define X_OK 1
  161. #define vfork fork
  162. #endif /* USG */
  163.  
  164. #if defined( _MSDOS )
  165. #define PATH_DELIMITER '\\'
  166. #define DOT_PATH       ".\\"
  167. #else
  168. #define PATH_DELIMITER '/'
  169. #define DOT_PATH       "./"
  170. #endif
  171.  
  172. #define obstack_chunk_alloc xmalloc
  173. #define obstack_chunk_free free
  174.  
  175. #include "gcc.h"
  176.  
  177. /* If a stage of compilation returns an exit status >= 1,
  178.    compilation of that file ceases.  */
  179.  
  180. #define MIN_FATAL_STATUS 1
  181.  
  182. /* This is the obstack which we use to allocate many strings.  */
  183.  
  184. struct obstack obstack;
  185.  
  186. char *handle_braces ();
  187. char *save_string ();
  188. char *concat ();
  189. int do_spec ();
  190. int do_spec_1 ();
  191. char *find_file ();
  192. static char *find_exec_file ();
  193. void validate_switches ();
  194. void validate_all_switches ();
  195. void fancy_abort ();
  196.  
  197. /* config.h can define ASM_SPEC to provide extra args to the assembler
  198.    or extra switch-translations.  */
  199. #ifndef ASM_SPEC
  200. #define ASM_SPEC ""
  201. #endif
  202.  
  203. /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
  204.    or extra switch-translations.  */
  205. #ifndef CPP_SPEC
  206. #define CPP_SPEC ""
  207. #endif
  208.  
  209. /* config.h can define CC1_SPEC to provide extra args to cc1
  210.    or extra switch-translations.  */
  211. #ifndef CC1_SPEC
  212. #define CC1_SPEC ""
  213. #endif
  214.  
  215. /* config.h can define LINK_SPEC to provide extra args to the linker
  216.    or extra switch-translations.  */
  217. #ifndef LINK_SPEC
  218. #define LINK_SPEC ""
  219. #endif
  220.  
  221. /* config.h can define LIB_SPEC to override the default libraries.  */
  222.  
  223. #if defined( DSP56000 ) || defined( DSP96000 )
  224. #ifndef LIB_SPEC
  225. #define LIB_SPEC "-L"
  226. #endif
  227.  
  228. #else
  229.  
  230. #ifndef LIB_SPEC
  231. #define LIB_SPEC "%{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}"
  232. #endif
  233.  
  234. #endif
  235.  
  236. /* config.h can define STARTFILE_SPEC to override the default crt0 files.  */
  237.  
  238. #if defined( DSP56000 ) || defined( DSP96000 )
  239.  
  240. #ifndef STARTFILE_SPEC
  241.  
  242. #if defined( DSP56000 )
  243. #define STARTFILE_SPEC  \
  244. "%{crt:%zc%s}%{!crt:%{mx-memory:crt056x.cln%s} \
  245.  %{!mx-memory:%{ml-memory:crt056l.cln%s}%{!ml-memory:crt056y.cln%s}}}"
  246. #else     /* DSP96002 */
  247. #define STARTFILE_SPEC  \
  248.  "%{crt:%zc%s}%{!crt:%{mx-memory:crt096x.cln%s} \
  249.   %{!mx-memory:%{my-memory:crt096y.cln%s}%{!my-memory:crt096l.cln%s}}}"
  250. #endif    /* DSP56000 */
  251.  
  252. #endif  /* STARTFILE_SPEC */
  253.  
  254. #else /* NON-DSP */
  255.  
  256. #ifndef STARTFILE_SPEC
  257. #define STARTFILE_SPEC  \
  258.   "%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}"
  259. #endif
  260.  
  261. #endif  /* DSP56000 || DSP96000 */
  262.  
  263.  
  264. /* This spec is used for telling cpp whether char is signed or not.  */
  265. #define SIGNED_CHAR_SPEC  \
  266.   (DEFAULT_SIGNED_CHAR ? "%{funsigned-char:-D__CHAR_UNSIGNED__}"    \
  267.    : "%{!fsigned-char:-D__CHAR_UNSIGNED__}")
  268.  
  269. /* This defines which switch letters take arguments.  */
  270.  
  271. #ifndef SWITCH_TAKES_ARG
  272. #if defined( DSP56000 ) || defined( DSP96000 )
  273. #define SWITCH_TAKES_ARG(CHAR)      \
  274.     ( (CHAR) == 'r' || (CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
  275.    || (CHAR) == 'j' || (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
  276.    || (CHAR) == 'I' || (CHAR) == 'Y' || (CHAR) == 'm' \
  277.    || (CHAR) == 'L' || (CHAR) == 'i' || (CHAR) == 'A')
  278. #else
  279. #define SWITCH_TAKES_ARG(CHAR)      \
  280.     ((CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
  281.    || (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
  282.    || (CHAR) == 'I' || (CHAR) == 'Y' || (CHAR) == 'm' \
  283.    || (CHAR) == 'L' || (CHAR) == 'i' || (CHAR) == 'A')
  284. #endif  /* DSP */
  285. #endif  /* SWITCH_TAKES_ARG */
  286.  
  287. /* This defines which multi-letter switches take arguments.  */
  288.  
  289. #ifndef WORD_SWITCH_TAKES_ARG
  290. #if defined( DSP56000 ) || defined( DSP96000 )
  291. #define WORD_SWITCH_TAKES_ARG(STR) (!strcmp (STR, "Tdata") \
  292.    || !strcmp(STR,"crt")) || !strcmp(STR,"asm")
  293. #else
  294. #define WORD_SWITCH_TAKES_ARG(STR) (!strcmp (STR, "Tdata"))
  295. #endif   /* DSP */
  296. #endif   /* WORD_SWITCH_TAKES_ARG */
  297.  
  298. /* This structure says how to run one compiler, and when to do so.  */
  299.  
  300. struct compiler
  301. {
  302.   char *suffix;            /* Use this compiler for input files
  303.                    whose names end in this suffix.  */
  304.   char *spec;            /* To use this compiler, pass this spec
  305.                    to do_spec.  */
  306. };
  307.  
  308. /* Here are the specs for compiling files with various known suffixes.
  309.    A file that does not end in any of these suffixes will be passed
  310.    unchanged to the loader and nothing else will be done to it.  */
  311.  
  312. struct compiler compilers[] =
  313. {
  314. #if defined( DSP56000 )
  315.   {".c",
  316.    "mcpp %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*} %{M*} %{i*} -undef \
  317.     %{mx-memory: -D__X_MEMORY} \
  318.     %{!mx-memory:%{ml-memory:-D__L_MEMORY} %{!ml-memory:-D__Y_MEMORY}} \
  319.     -trigraphs -$ -D__STRICT_ANSI__ %P %c %{pedantic} \
  320.     %{!-fno-opt:-D__OPTIMIZE__} %{Wcomment*} %{Wtrigraphs} %{Wall} %i \
  321.     %{!M*:%{!E:%g.cpp}}%{E:%{o*}}%{M*:%{o*}} |\n\
  322.     %{!M*:%{!E:g56-cc1 %g.cpp -ansi -fstrength-reduce %{!Q:-quiet} -dumpbase %i \
  323.     %{g} %{!g: %{S*: -g}} %{d*} %{m*} %{!fno-opt:-O} %{O} %{f*} %{W*} %{w} \
  324.     %{pedantic} %{v:-version} %{S*:%{o*} %{!o*:-o %b.asm}} %{!S*:-o %g.asm} |\n\
  325.     %{!S*:%{alo: alo56 -i %g.asm}} \
  326.     %{S*:%{!o*:%{alo: alo56 -i %b.asm}} %{o*:%{alo: alo56 -i %zo}}} |\n\
  327.     %{S:%{!o*:%{g: annotate -keep %b.asm} %{!g: %{S: annotate %b.asm}}} \
  328.         %{o*:%{g: annotate -keep %zo} %{!g: %{S: annotate %zo}}}} |\n\
  329.     %{!S*:asm56000 -c %{g} %{asm:%za} %{c:%{o*:-B %zo --}%{!o*:-B %w%b.cln --}}\
  330.     %{!c:-B %d%w%b.cln --} %g.asm\n }}}"},
  331.  
  332.   {".i",
  333.    "g56-cc1 %i -ansi -fstrength-reduce %{!Q:-quiet} -dumpbase %{d*} %{m*} %{f*}\
  334.     %{g} %{!g: %{S*: -g}} %{!-fno-opt:-O} %{O} %{W*} %{w} %{pedantic}\
  335.     %{v:-version} %{S*:%{o*} %{!o*:-o %b.asm}} %{!S*:-o %g.asm} |\n\
  336.     %{!S*:asm56000 -c %{g} %{asm:%za} %{c:%{o*:-B %zo --}%{!o*:-B %w%b.cln --}}\
  337.     %{!c:-B %d%w%b.cln --} %g.asm\n }"},
  338.  
  339.   {".asm",
  340.    "%{!S:asm56000 -c %{g} %{asm:%za} %{c:%{o*:-B %zo --}%{!o*:-B %w%b.cln --}}\
  341.     %{!c:-B %d%w%b.cln --} %i\n }"},
  342. #endif
  343.  
  344.  
  345. #if defined( DSP96000 )
  346.   {".c",
  347.    "mcpp %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*} %{M*} %{i*} -undef \
  348.     %{mx-memory: -D__X_MEMORY} \
  349.     %{!mx-memory:%{my-memory:-D__Y_MEMORY} %{!my-memory:-D__L_MEMORY}} \
  350.     -trigraphs -$ -D__STRICT_ANSI__ %P %c %{pedantic} \
  351.     %{!-fno-opt:-D__OPTIMIZE__} %{Wcomment*} %{Wtrigraphs} %{Wall} %i \
  352.     %{!M*:%{!E:%g.cpp}}%{E:%{o*}}%{M*:%{o*}} |\n\
  353.     %{!M*:%{!E:g96-cc1 %g.cpp -ansi -fstrength-reduce %{!Q:-quiet} -dumpbase %i \
  354.     %{d*} %{m*} %{f*} %{g} %{!g: %{S*: -g}} %{!-fno-opt:-O} %{O} %{W*} %{w} \
  355.     %{pedantic} %{v:-version} %{S*:%{o*}%{!o*:-o %b.asm}} %{!S*:-o %g.asm} |\n\
  356.     %{!S*:%{alo: alo96 -i %g.asm}} \
  357.     %{S:%{!o*:%{alo: alo96 -i %b.asm}} %{o*:%{alo: alo96 -i %zo}}} |\n\
  358.     %{S:%{!o*:%{g: annotate -keep %b.asm} %{!g: %{S: annotate %b.asm}}} \
  359.         %{o*:%{g: annotate -keep %zo} %{!g: %{S: annotate %zo}}}} |\n\
  360.     %{!S*:asm96000 -c %{g} %{asm:%za} %{c:%{o*:-B %zo --}%{!o*:-B %w%b.cln --}}\
  361.     %{!c:-B %d%w%b.cln --} %g.asm\n }}}"},
  362.  
  363.   {".i",
  364.    "g96-cc1 %i -ansi -fstrength-reduce %{!Q:-quiet} -dumpbase %{d*} %{m*} %{f*} \
  365.     %{g} %{!g: %{S*: -g}} %{!-fno-opt:-O} %{O} %{W*} %{w} %{pedantic} \
  366.     %{v:-version} %{S*:%{o*}%{!o*:-o %b.asm}} %{!S*:-o %g.asm} |\n\
  367.     %{!S*:asm96000 -c %{g} %{asm:%za} %{c:%{o*:-B %zo --}%{!o*:-B %w%b.cln --}}\
  368.     %{!c:-B %d%w%b.cln --} %g.asm\n }"},
  369.  
  370.   {".asm",
  371.    "%{!S:asm96000 -c %{g} %{asm:%za} %{c:%{o*:-B %zo --}%{!o*:-B %w%b.cln --}}\
  372.     %{!c:-B %d%w%b.cln --} %i\n }"},
  373. #endif
  374.  
  375. #if ! defined( DSP96000 ) && ! defined( DSP56000 )
  376.   {".c",
  377.    "cpp %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*} %{M*} %{i*} %{trigraphs} -undef \
  378.         -D__GNUC__ %{ansi:-trigraphs -$ -D__STRICT_ANSI__} %{!ansi:%p} %P\
  379.         %c %{O:-D__OPTIMIZE__} %{traditional} %{pedantic}\
  380.     %{Wcomment*} %{Wtrigraphs} %{Wall} %C\
  381.         %i %{!M*:%{!E:%{!pipe:%g.cpp}}}%{E:%{o*}}%{M*:%{o*}} |\n\
  382.     %{!M*:%{!E:cc1 %{!pipe:%g.cpp} %1 \
  383.            %{!Q:-quiet} -dumpbase %i %{Y*} %{d*} %{m*} %{f*} %{a}\
  384.            %{g} %{O} %{W*} %{w} %{pedantic} %{ansi} %{traditional}\
  385.            %{v:-version} %{gg:-symout %g.sym} %{pg:-p} %{p}\
  386.            %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  387.            %{S:%{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  388.               %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %{gg:-G %g.sym}\
  389.               %{c:%{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%b.o}\
  390.                       %{!pipe:%g.s}\n }}}"},
  391.   {".cc",
  392.    "cpp -+ %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*} %{M*} %{i*} \
  393.         -undef -D__GNUC__ -D__GNUG__ %p %P\
  394.         %c %{O:-D__OPTIMIZE__} %{traditional} %{pedantic}\
  395.     %{Wcomment*} %{Wtrigraphs} %{Wall} %C\
  396.         %i %{!M*:%{!E:%{!pipe:%g.cpp}}}%{E:%{o*}}%{M*:%{o*}} |\n\
  397.     %{!M*:%{!E:cc1plus %{!pipe:%g.cpp} %1\
  398.            %{!Q:-quiet} -dumpbase %i %{Y*} %{d*} %{m*} %{f*} %{a}\
  399.            %{g} %{O} %{W*} %{w} %{pedantic} %{traditional}\
  400.            %{v:-version} %{gg:-symout %g.sym} %{pg:-p} %{p}\
  401.            %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  402.            %{S:%{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  403.               %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %{gg:-G %g.sym}\
  404.               %{c:%{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%b.o}\
  405.                       %{!pipe:%g.s}\n }}}"},
  406.   {".i",
  407.    "cc1 %i %1 %{!Q:-quiet} %{Y*} %{d*} %{m*} %{f*} %{a}\
  408.     %{g} %{O} %{W*} %{w} %{pedantic} %{ansi} %{traditional}\
  409.     %{v:-version} %{gg:-symout %g.sym} %{pg:-p} %{p}\
  410.     %{S:%{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  411.     %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %{gg:-G %g.sym}\
  412.             %{c:%{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%b.o} %{!pipe:%g.s}\n }"},
  413.   {".s",
  414.    "%{!S:as %{R} %{j} %{J} %{h} %{d2} %a \
  415.             %{c:%{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%b.o} %i\n }"},
  416.   {".S",
  417.    "cpp %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*} %{M*} %{trigraphs} \
  418.         -undef -D__GNUC__ -$ %p %P\
  419.         %c %{O:-D__OPTIMIZE__} %{traditional} %{pedantic}\
  420.     %{Wcomment*} %{Wtrigraphs} %{Wall} %C\
  421.         %i %{!M*:%{!E:%{!pipe:%g.s}}}%{E:%{o*}}%{M*:%{o*}} |\n\
  422.     %{!M*:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a \
  423.                     %{c:%{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%b.o}\
  424.             %{!pipe:%g.s}\n }}}"},
  425. #endif
  426.  
  427.   /* Mark end of table */
  428.   {0, 0}
  429. };
  430.  
  431.  
  432. /* Here is the spec for running the linker, after compiling all files.  */
  433. #if defined( DSP56000 )
  434. char *link_spec = "%{!c:%{!M*:%{!E:%{!S*:dsplnk -c %{g} %{j:%zj} \
  435. %{r:-R %zr%s} %{o:-B %zo --} %{!o:-B a.cld --} %l %{F*} \
  436. %{I} %S %o %{mx-memory:%L lib56cx.clb%s} \
  437. %{!mx-memory:%{ml-memory: %L lib56cl.clb%s}%{!ml-memory:%L lib56cy.clb%s}} \
  438. %{L*}\n}}}}";
  439. #endif
  440.  
  441.  
  442. #if defined( DSP96000 )
  443. char *link_spec = "%{!c:%{!M*:%{!E:%{!S*:dsplnk -c %{g} %{j:%zj} \
  444. %{r:-R %zr%s} %{o:-B %zo --} %{!o:-B a.cld --} %l %{F*} \
  445. %{I} %S %o %{mx-memory:%L lib96cx.clb%s} \
  446. %{!mx-memory:%{my-memory: %L lib96cy.clb%s}%{!my-memory:%L lib96cl.clb%s}} \
  447. %{L*}\n}}}}";
  448. #endif
  449.  
  450.  
  451. #if ! defined( DSP56000 ) && ! defined( DSP96000 )
  452. char *link_spec = "%{!c:%{!M*:%{!E:%{!S:ld -dc -dp -e start -X %{o*} %l\
  453.  %{A} %{d} %{e*} %{N} %{n} %{r} %{s} %{S} %{T*} %{t} %{u*} %{X} %{x} %{z}\
  454.  %{y*} %{!A:%{!nostdlib:%S}} \
  455.  %{L*} %o %{!nostdlib:%{g:-lg} %L gnulib%s}\n }}}}";
  456. #endif
  457.  
  458. /* Accumulate a command (program name and args), and run it.  */
  459.  
  460. /* Vector of pointers to arguments in the current line of specifications.  */
  461.  
  462. char **argbuf;
  463.  
  464. /* Number of elements allocated in argbuf.  */
  465.  
  466. int argbuf_length;
  467.  
  468. /* Number of elements in argbuf currently in use (containing args).  */
  469.  
  470. int argbuf_index;
  471.  
  472. /* Number of commands executed so far.  */
  473.  
  474. int execution_count;
  475.  
  476. /* Flag indicating whether we should print the command and arguments */
  477.  
  478. unsigned char vflag;
  479.  
  480. /* Name with which this program was invoked.  */
  481.  
  482. char *programname;
  483.  
  484. /* User-specified -B prefix to attach to command names,
  485.    or 0 if none specified.  */
  486.  
  487. char *user_exec_prefix = 0;
  488.  
  489. /* Environment-specified prefix to attach to command names,
  490.    or 0 if none specified.  */
  491.  
  492. char *env_exec_prefix = 0;
  493.  
  494. /* Suffix to attach to directories searched for commands.  */
  495.  
  496. char *machine_suffix = 0;
  497.  
  498. /* Default prefixes to attach to command names.  */
  499.  
  500. #if defined( DSP96000 )
  501. #if defined( _MSDOS )
  502. #define STANDARD_EXEC_PREFIX "c:\\dsp\\bin\\g96-"
  503. #else
  504. #define STANDARD_EXEC_PREFIX "/usr/local/dsp/bin/gcc96-"
  505. #endif /* _MSDOS */
  506. #endif /* DSP96000 */
  507.  
  508. #if defined( DSP56000 )
  509. #if defined( _MSDOS )
  510. #define STANDARD_EXEC_PREFIX "c:\\dsp\\bin\\g56-"
  511. #else
  512. #define STANDARD_EXEC_PREFIX "/usr/local/dsp/bin/gcc56-"
  513. #endif /* _MSDOS */
  514. #endif /* DSP56000 */
  515.  
  516. #if !defined( DSP56000 ) && !defined( DSP96000 )
  517.  
  518. #if defined( _MSDOS )
  519. #define STANDARD_EXEC_PREFIX "c:\\usr\\local\\lib\\gcc-"
  520. #else
  521. #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-"
  522. #endif /* ! DOS */
  523.  
  524. #endif /* !defined STANDARD_EXEC_PREFIX */
  525.  
  526.  
  527. char *standard_exec_prefix = STANDARD_EXEC_PREFIX;
  528.  
  529. #if defined( DSP56000 ) || defined( DSP96000 )
  530.  
  531. #if defined( _MSDOS )
  532. char *standard_exec_prefix_1 = "c:\\dsp\\bin\\";
  533. #else
  534. char *standard_exec_prefix_1 = "/usr/local/dsp/bin/";
  535. #endif  /* DOS */
  536.  
  537. #endif  /* DSP */
  538.  
  539. #if !defined( DSP56000 ) && !defined( DSP96000 )
  540. char *standard_exec_prefix_1 = "/usr/local/gnu/lib/gcc-";
  541. #endif
  542.  
  543.  
  544. #if defined( DSP96000 ) || defined( DSP56000 )
  545. #if defined( _MSDOS )
  546. #define STANDARD_STARTFILE_PREFIX "c:\\dsp\\lib\\"
  547. #else
  548. #define STANDARD_STARTFILE_PREFIX "/usr/local/dsp/lib/"
  549. #endif /* _MSDOS */
  550. #endif /* DSP96000 */
  551.  
  552. #ifndef STANDARD_STARTFILE_PREFIX
  553.  
  554. #if defined( _MSDOS )
  555. #define STANDARD_STARTFILE_PREFIX "c:\\dsp\\lib\\"
  556. #else
  557. #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
  558. #endif  /* DOS */
  559.  
  560. #endif /* !defined STANDARD_STARTFILE_PREFIX */
  561.  
  562.  
  563. char *standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
  564.  
  565. #if defined ( _MSDOS )
  566. char *standard_startfile_prefix_1 = "c:\\dsp\\lib\\";
  567. char *standard_startfile_prefix_2 = "c:\\dsp\\lib\\";
  568. #else
  569. char *standard_startfile_prefix_1 = "/lib/";
  570. char *standard_startfile_prefix_2 = "/usr/lib/";
  571. #endif  /* HIGH */
  572.  
  573.  
  574. /* Clear out the vector of arguments (after a command is executed).  */
  575.  
  576. void
  577. clear_args ()
  578. {
  579.   argbuf_index = 0;
  580. }
  581.  
  582.  
  583. /* Add one argument to the vector at the end.
  584.    This is done when a space is seen or at the end of the line.
  585.    If DELETE_ALWAYS is nonzero, the arg is a filename
  586.     and the file should be deleted eventually.
  587.    If DELETE_FAILURE is nonzero, the arg is a filename
  588.     and the file should be deleted if this compilation fails.  */
  589.  
  590. void
  591. store_arg (arg, delete_always, delete_failure)
  592.      char *arg;
  593.      int delete_always, delete_failure;
  594. {
  595.   if (argbuf_index + 1 == argbuf_length)
  596.     {
  597.       argbuf = (char **) realloc (argbuf, (argbuf_length *= 2) * sizeof (char *));
  598.     }
  599.  
  600.   argbuf[argbuf_index++] = arg;
  601.   argbuf[argbuf_index] = 0;
  602.  
  603.   if (delete_always || delete_failure)
  604.     record_temp_file (arg, delete_always, delete_failure);
  605. }
  606.  
  607. /* Record the names of temporary files we tell compilers to write,
  608.    and delete them at the end of the run.  */
  609.  
  610. /* This is the common prefix we use to make temp file names.
  611.    It is chosen once for each run of this program.
  612.    It is substituted into a spec by %g.
  613.    Thus, all temp file names contain this prefix.
  614.    In practice, all temp file names start with this prefix.
  615.  
  616.    This prefix comes from the envvar TMPDIR if it is defined;
  617.    otherwise, from the P_tmpdir macro if that is defined;
  618.    otherwise, in /usr/tmp or /tmp.  */
  619.  
  620. char *temp_filename;
  621.  
  622. /* Length of the prefix.  */
  623.  
  624. int temp_filename_length;
  625.  
  626. /* Define the list of temporary files to delete.  */
  627.  
  628. struct temp_file
  629. {
  630.   char *name;
  631.   struct temp_file *next;
  632. };
  633.  
  634. /* Queue of files to delete on success or failure of compilation.  */
  635. struct temp_file *always_delete_queue;
  636. /* Queue of files to delete on failure of compilation.  */
  637. struct temp_file *failure_delete_queue;
  638.  
  639. /* Record FILENAME as a file to be deleted automatically.
  640.    ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
  641.    otherwise delete it in any case.
  642.    FAIL_DELETE nonzero means delete it if a compilation step fails;
  643.    otherwise delete it in any case.  */
  644.  
  645. void
  646. record_temp_file (filename, always_delete, fail_delete)
  647.      char *filename;
  648.      int always_delete;
  649.      int fail_delete;
  650. {
  651.   register char *name;
  652.   name = (char *) xmalloc (strlen (filename) + 1);
  653.   strcpy (name, filename);
  654.  
  655.   if (always_delete)
  656.     {
  657.       register struct temp_file *temp;
  658.       for (temp = always_delete_queue; temp; temp = temp->next)
  659.     if (! strcmp (name, temp->name))
  660.       goto already1;
  661.       temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
  662.       temp->next = always_delete_queue;
  663.       temp->name = name;
  664.       always_delete_queue = temp;
  665.     already1:;
  666.     }
  667.  
  668.   if (fail_delete)
  669.     {
  670.       register struct temp_file *temp;
  671.       for (temp = failure_delete_queue; temp; temp = temp->next)
  672.     if (! strcmp (name, temp->name))
  673.       goto already2;
  674.       temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
  675.       temp->next = failure_delete_queue;
  676.       temp->name = name;
  677.       failure_delete_queue = temp;
  678.     already2:;
  679.     }
  680. }
  681.  
  682. /* Delete all the temporary files whose names we previously recorded.  */
  683.  
  684. void
  685. delete_temp_files ()
  686. {
  687.   register struct temp_file *temp;
  688.  
  689.   for (temp = always_delete_queue; temp; temp = temp->next)
  690.     {
  691. #ifdef DEBUG
  692.       int i;
  693.       printf ("Delete %s? (y or n) ", temp->name);
  694.       fflush (stdout);
  695.       i = getchar ();
  696.       if (i != '\n')
  697.     while (getchar () != '\n') ;
  698.       if (i == 'y' || i == 'Y')
  699. #endif /* DEBUG */
  700.     {
  701.       if (unlink (temp->name) < 0)
  702.         if (vflag)
  703.           perror_with_name (temp->name);
  704.     }
  705.     }
  706.  
  707.   always_delete_queue = 0;
  708. }
  709.  
  710. /* Delete all the files to be deleted on error.  */
  711.  
  712. void
  713. delete_failure_queue ()
  714. {
  715.   register struct temp_file *temp;
  716.  
  717.   for (temp = failure_delete_queue; temp; temp = temp->next)
  718.     {
  719. #ifdef DEBUG
  720.       int i;
  721.       printf ("Delete %s? (y or n) ", temp->name);
  722.       fflush (stdout);
  723.       i = getchar ();
  724.       if (i != '\n')
  725.     while (getchar () != '\n') ;
  726.       if (i == 'y' || i == 'Y')
  727. #endif /* DEBUG */
  728.     {
  729.       if (unlink (temp->name) < 0)
  730.         if (vflag)
  731.           perror_with_name (temp->name);
  732.     }
  733.     }
  734. }
  735.  
  736. void
  737. clear_failure_queue ()
  738. {
  739.   failure_delete_queue = 0;
  740. }
  741.  
  742. /* Compute a string to use as the base of all temporary file names.
  743.    It is substituted for %g.  */
  744.  
  745. void
  746. choose_temp_base ()
  747. {
  748.   extern char *getenv ();
  749.   char *base = getenv ("TMPDIR");
  750.   int len;
  751.  
  752. #if defined( _MSDOS )
  753.   /* force the fabulous PC to use the current directory as the temp space */
  754.   temp_filename = (char *) xmalloc ( sizeof("ccXXXXXX") );
  755.   strcpy (temp_filename, "ccXXXXXX");
  756. #else
  757.   if (base == (char *)0)
  758.     {
  759. #ifdef P_tmpdir
  760.       if (access (P_tmpdir, R_OK | W_OK) == 0)
  761.     base = P_tmpdir;
  762. #endif  /* P_tmpdir */
  763.  
  764.       if (base == (char *)0)
  765.     {
  766.       if (access ("/usr/tmp", R_OK | W_OK) == 0)
  767.         base = "/usr/tmp/";
  768.       else
  769.         base = "/tmp/";
  770.     }
  771.     }
  772.  
  773.   len = strlen (base);
  774.   temp_filename = (char *) xmalloc (len + sizeof("/ccXXXXXX"));
  775.   strcpy (temp_filename, base);
  776.  
  777.   if (len > 0 && temp_filename[len-1] != PATH_DELIMITER)
  778.     temp_filename[len++] = PATH_DELIMITER;
  779.  
  780.   strcpy (temp_filename + len, "ccXXXXXX");
  781. #endif
  782.  
  783.   mktemp (temp_filename);
  784. #ifdef __TURBOC__
  785.   temp_filename[ strlen(temp_filename)-4 ] = '_';
  786. #endif
  787.   temp_filename_length = strlen (temp_filename);
  788. }
  789.  
  790. /* Search for an execute file through our search path.
  791.    Return 0 if not found, otherwise return its name, allocated with malloc.  */
  792.  
  793. static char *
  794. find_exec_file (prog)
  795.      char *prog;
  796. {
  797.   int win = 0;
  798.   char *temp;
  799.   int size;
  800.  
  801. #if defined( _MSDOS )
  802.   /* fabulous pc requires .exe extension */
  803.   char *ptmp = xmalloc( strlen(prog)+5 );
  804.   strcpy( ptmp, prog );
  805.   strcat( ptmp, ".exe" );
  806.   prog = ptmp;
  807. #endif
  808.  
  809.   size = strlen (standard_exec_prefix);
  810.   if (user_exec_prefix != 0 && strlen (user_exec_prefix) > size)
  811.     size = strlen (user_exec_prefix);
  812.   if (env_exec_prefix != 0 && strlen (env_exec_prefix) > size)
  813.     size = strlen (env_exec_prefix);
  814.   if (strlen (standard_exec_prefix_1) > size)
  815.     size = strlen (standard_exec_prefix_1);
  816.  
  817.   size += strlen (prog) + 1;
  818.  
  819.   if (machine_suffix)
  820.     size += strlen (machine_suffix) + 1;
  821.   temp = (char *) xmalloc (size);
  822.  
  823.   /* Determine the filename to execute.  */
  824.  
  825.   if (user_exec_prefix)
  826.     {
  827.       if (machine_suffix)
  828.     {
  829.       strcpy (temp, user_exec_prefix);
  830.       strcat (temp, machine_suffix);
  831.       strcat (temp, prog);
  832.  
  833.       if ( access( temp, X_OK ) == 0 )
  834.       {
  835.           win = 1;
  836.       }
  837.       else
  838.       {
  839.           win = 0;
  840.       }
  841.         }
  842.  
  843.       if (!win)
  844.     {
  845.       strcpy (temp, user_exec_prefix);
  846.       strcat (temp, prog);
  847.  
  848.       if ( access( temp, X_OK ) == 0 )
  849.       {
  850.           win = 1;
  851.       }
  852.       else
  853.       {
  854.           win = 0;
  855.       }
  856.     }
  857.     }
  858.  
  859.   if (!win && env_exec_prefix)
  860.     {
  861.       if (machine_suffix)
  862.     {
  863.       strcpy (temp, env_exec_prefix);
  864.       strcat (temp, machine_suffix);
  865.       strcat (temp, prog);
  866.  
  867.       if ( access( temp, X_OK ) == 0 )
  868.       {
  869.           win = 1;
  870.       }
  871.       else
  872.       {
  873.           win = 0;
  874.       }
  875.     }
  876.       if (!win)
  877.     {
  878.       strcpy (temp, env_exec_prefix);
  879.       strcat (temp, prog);
  880.  
  881.       if ( access( temp, X_OK ) == 0 )
  882.       {
  883.           win = 1;
  884.       }
  885.       else
  886.       {
  887.           win = 0;
  888.       }
  889.     }
  890.     }
  891.  
  892.   if (!win)
  893.     {
  894.       if (machine_suffix)
  895.     {
  896.       strcpy (temp, standard_exec_prefix);
  897.       strcat (temp, machine_suffix);
  898.       strcat (temp, prog);
  899.  
  900.       if ( access( temp, X_OK ) == 0 )
  901.       {
  902.           win = 1;
  903.       }
  904.       else
  905.       {
  906.           win = 0;
  907.       }
  908.     }
  909.       if (!win)
  910.     {
  911.       strcpy (temp, standard_exec_prefix);
  912.       strcat (temp, prog);
  913.  
  914.       if ( access( temp, X_OK ) == 0 )
  915.       {
  916.           win = 1;
  917.       }
  918.       else
  919.       {
  920.           win = 0;
  921.       }
  922.     }
  923.     }
  924.  
  925.   if (!win)
  926.     {
  927.       if (machine_suffix)
  928.     {
  929.       strcpy (temp, standard_exec_prefix_1);
  930.       strcat (temp, machine_suffix);
  931.       strcat (temp, prog);
  932.  
  933.       if ( access( temp, X_OK ) == 0 )
  934.       {
  935.           win = 1;
  936.       }
  937.       else
  938.       {
  939.           win = 0;
  940.       }
  941.     }
  942.       if (!win)
  943.     {
  944.       strcpy (temp, standard_exec_prefix_1);
  945.       strcat (temp, prog);
  946.  
  947.       if ( access( temp, X_OK ) == 0 )
  948.       {
  949.           win = 1;
  950.       }
  951.       else
  952.       {
  953.           win = 0;
  954.       }
  955.     }
  956.     }
  957.  
  958.   if (win)
  959.     return temp;
  960.   else
  961.     return 0;
  962. }
  963.  
  964. /* stdin file number.  */
  965. #define STDIN_FILE_NO 0
  966.  
  967. /* stdout file number.  */
  968. #define STDOUT_FILE_NO 1
  969.  
  970. /* value of `pipe': port index for reading.  */
  971. #define READ_PORT 0
  972.  
  973. /* value of `pipe': port index for writing.  */
  974. #define WRITE_PORT 1
  975.  
  976. /* Pipe waiting from last process, to be used as input for the next one.
  977.    Value is STDIN_FILE_NO if no pipe is waiting
  978.    (i.e. the next command is the first of a group).  */
  979.  
  980. int last_pipe_input;
  981.  
  982. /* Fork one piped subcommand.  FUNC is the system call to use
  983.    (either execv or execvp).  ARGV is the arg vector to use.
  984.    NOT_LAST is nonzero if this is not the last subcommand
  985.    (i.e. its output should be piped to the next one.)  */
  986.  
  987. static int
  988. pexecute (func, program, argv, not_last)
  989.      char *program;
  990.      int (*func)();
  991.      char *argv[];
  992.      int not_last;
  993. {
  994.   int pid;
  995.   int pdes[2];
  996.   int input_desc = last_pipe_input;
  997.   int output_desc = STDOUT_FILE_NO;
  998. #if defined( DSP56000 ) || defined( DSP96000 )
  999.   int tmp_file_used = 0;
  1000.   char *arg_file_name;
  1001. #endif
  1002.  
  1003. #if defined( DSP56000 ) || defined( DSP96000 )
  1004.   /* the fabulous DOS OS limits the command line length */
  1005.   {
  1006.       FILE *arg_file;
  1007.       int i = 0, command_line_length = 0;
  1008.       int arg_file_name_length = 5;
  1009.         
  1010.       while ( argv[ i ] != NULL )
  1011.       {
  1012.       command_line_length += strlen( argv[i] );
  1013.  
  1014.       /* send everything over 100 characters to temp file */
  1015.       if ( command_line_length > 100 )
  1016.       {
  1017.           tmp_file_used = 1;
  1018.           i -- ;     /* this assumes that the program name < 100 */
  1019.           break;
  1020.       }
  1021.  
  1022.       i ++ ;
  1023.       }
  1024.         
  1025.       if ( tmp_file_used )
  1026.       {
  1027.       /* point to insert the -F flag and filename argument */
  1028.       int f_point = i;
  1029.         
  1030.       /* create temp file */
  1031.       arg_file_name_length += strlen( temp_filename );
  1032.       arg_file_name = (char*) xmalloc( arg_file_name_length );
  1033.       strcpy ( arg_file_name, temp_filename );
  1034.       strcat ( arg_file_name, ".arg" );
  1035.  
  1036.       record_temp_file (arg_file_name, 1, 1);
  1037.  
  1038.       /* open file */
  1039.       if ( ( arg_file = fopen( arg_file_name, "w" ) ) == NULL )
  1040.       {
  1041.           perror( "arg_file open" );
  1042.           exit ( -1 );
  1043.       }
  1044.  
  1045.       /* blow remaining argv contents to file */
  1046.       while ( argv[ i ] != NULL )
  1047.       {
  1048.           fprintf( arg_file, "%s\n", argv[ i ] );
  1049.           i ++ ;
  1050.       }
  1051.         
  1052.       /* close up */
  1053.       fclose( arg_file );    
  1054.         
  1055.       /* add "-F arg_file_name" */
  1056.       argv[ f_point ] = (char *) xmalloc ( 3 );
  1057.       strcpy( argv[ f_point ], "-F" );
  1058.       f_point ++ ;
  1059.       argv[ f_point ] = arg_file_name;
  1060.  
  1061.       /* reset vector end point with NULL */
  1062.       f_point ++ ;
  1063.       argv[ f_point ] = NULL;
  1064.       }
  1065.   }
  1066. #endif
  1067.  
  1068. #if ! defined( _MSDOS )
  1069.   /* If this isn't the last process, make a pipe for its output,
  1070.      and record it as waiting to be the input to the next process.  */
  1071.  
  1072.   if (not_last)
  1073.     {
  1074.       if (pipe (pdes) < 0)
  1075.     pfatal_with_name ("pipe");
  1076.       output_desc = pdes[WRITE_PORT];
  1077.       last_pipe_input = pdes[READ_PORT];
  1078.     }
  1079.   else
  1080.     last_pipe_input = STDIN_FILE_NO;
  1081.  
  1082.   pid = vfork ();
  1083.  
  1084.   switch (pid)
  1085.     {
  1086.     case -1:
  1087.       pfatal_with_name ("vfork");
  1088.       break;
  1089.  
  1090.     case 0: /* child */
  1091.       /* Move the input and output pipes into place, if nec.  */
  1092.       if (input_desc != STDIN_FILE_NO)
  1093.     {
  1094.       close (STDIN_FILE_NO);
  1095.       dup (input_desc);
  1096.       close (input_desc);
  1097.     }
  1098.       if (output_desc != STDOUT_FILE_NO)
  1099.     {
  1100.       close (STDOUT_FILE_NO);
  1101.       dup (output_desc);
  1102.       close (output_desc);
  1103.     }
  1104.  
  1105.       /* Close the parent's descs that aren't wanted here.  */
  1106.       if (last_pipe_input != STDIN_FILE_NO)
  1107.     close (last_pipe_input);
  1108.  
  1109.       /* Exec the program.  */
  1110.       (*func) (program, argv);
  1111.       perror_exec (program);
  1112.       exit (-1);
  1113.       /* NOTREACHED */
  1114.  
  1115.     default:
  1116.       /* In the parent, after forking.
  1117.      Close the descriptors that we made for this child.  */
  1118.       if (input_desc != STDIN_FILE_NO)
  1119.     close (input_desc);
  1120.       if (output_desc != STDOUT_FILE_NO)
  1121.     close (output_desc);
  1122.  
  1123.       /* Return child's process number.  */
  1124.       return pid;
  1125.     }
  1126. #else
  1127.   /* Exec the program.  */
  1128.   if ( (*func) ( P_WAIT, program, argv) != 0 )
  1129.   {
  1130.       perror_with_name(program);
  1131.       exit (-1);
  1132.       /* NOTREACHED */
  1133.   }
  1134. #endif  /* ! DOS */
  1135. }
  1136.  
  1137. /* Execute the command specified by the arguments on the current line of spec.
  1138.    When using pipes, this includes several piped-together commands
  1139.    with `|' between them.
  1140.  
  1141.    Return 0 if successful, -1 if failed.  */
  1142.  
  1143. int
  1144. execute ()
  1145. {
  1146.   int i;
  1147.   int n_commands;        /* # of command.  */
  1148.   char *string;
  1149.   struct command
  1150.     {
  1151.       char *prog;        /* program name.  */
  1152.       char **argv;        /* vector of args.  */
  1153.       int pid;            /* pid of process for this command.  */
  1154.     };
  1155.  
  1156.   struct command *commands;    /* each command buffer with above info.  */
  1157.  
  1158. #if ! defined( _MSDOS )
  1159.   /* Count # of piped commands.  */
  1160.   for (n_commands = 1, i = 0; i < argbuf_index; i++)
  1161.     if (strcmp (argbuf[i], "|") == 0)
  1162.       n_commands++;
  1163. #else
  1164.   n_commands = 1;
  1165. #endif
  1166.  
  1167.   /* Get storage for each command.  */
  1168.   commands
  1169.     = (struct command *) alloca (n_commands * sizeof (struct command));
  1170.  
  1171.   /* Split argbuf into its separate piped processes,
  1172.      and record info about each one.
  1173.      Also search for the programs that are to be run.  */
  1174.  
  1175.   commands[0].prog = argbuf[0]; /* first command.  */
  1176.   commands[0].argv = &argbuf[0];
  1177.   string = find_exec_file (commands[0].prog);
  1178.   if (string)
  1179.     commands[0].argv[0] = string;
  1180.  
  1181.   for (n_commands = 1, i = 0; i < argbuf_index; i++)
  1182.     if (strcmp (argbuf[i], "|") == 0)
  1183.       {                /* each command.  */
  1184.     argbuf[i] = 0;    /* termination of command args.  */
  1185.     commands[n_commands].prog = argbuf[i + 1];
  1186.     commands[n_commands].argv = &argbuf[i + 1];
  1187.     string = find_exec_file (commands[n_commands].prog);
  1188.     if (string)
  1189.       commands[n_commands].argv[0] = string;
  1190.     n_commands++;
  1191.       }
  1192.  
  1193.   argbuf[argbuf_index] = 0;
  1194.  
  1195.   /* If -v, print what we are about to do, and maybe query.  */
  1196.  
  1197.   if (vflag)
  1198.     {
  1199.       /* Print each piped command as a separate line.  */
  1200.       for (i = 0; i < n_commands ; i++)
  1201.     {
  1202.       char **j;
  1203.  
  1204.       for (j = commands[i].argv; *j; j++)
  1205.         fprintf (stderr, " %s", *j);
  1206.  
  1207.       /* Print a pipe symbol after all but the last command.  */
  1208.       if (i + 1 != n_commands)
  1209.         fprintf (stderr, " |");
  1210.       fprintf (stderr, "\n");
  1211.     }
  1212.       fflush (stderr);
  1213. #ifdef DEBUG
  1214.       fprintf (stderr, "\nGo ahead? (y or n) ");
  1215.       fflush (stderr);
  1216.       j = getchar ();
  1217.       if (j != '\n')
  1218.     while (getchar () != '\n') ;
  1219.       if (j != 'y' && j != 'Y')
  1220.     return 0;
  1221. #endif /* DEBUG */
  1222.     }
  1223.  
  1224.   /* Run each piped subprocess.  */
  1225.  
  1226.   last_pipe_input = STDIN_FILE_NO;
  1227.   for (i = 0; i < n_commands; i++)
  1228.     {
  1229. #if ! defined( _MSDOS )
  1230.       extern int execv(), execvp();
  1231. #else
  1232.       extern int spawnv(), spawnvp();
  1233. #endif
  1234.       char *string = commands[i].argv[0];
  1235.  
  1236. #if ! defined( _MSDOS )
  1237.       commands[i].pid = pexecute ((string != commands[i].prog ? execv : execvp),
  1238.                   string, commands[i].argv,
  1239.                   i + 1 < n_commands);
  1240. #else
  1241.       commands[i].pid = pexecute ((string != commands[i].prog ? spawnv : spawnvp),
  1242.                   string, commands[i].argv,
  1243.                   i + 1 < n_commands);
  1244. #endif  /* DOS */
  1245.  
  1246.       if (string != commands[i].prog)
  1247.     free (string);
  1248.     }
  1249.  
  1250.   execution_count++;
  1251.  
  1252.   /* Wait for all the subprocesses to finish.
  1253.      We don't care what order they finish in;
  1254.      we know that N_COMMANDS waits will get them all.  */
  1255.  
  1256.   {
  1257.     int ret_code = 0;
  1258.  
  1259.     for (i = 0; i < n_commands; i++)
  1260.       {
  1261.     int status;
  1262.     int pid;
  1263.     char *prog;
  1264.  
  1265. #if ! defined( _MSDOS )
  1266.     pid = wait (&status);
  1267.     if (pid < 0)
  1268.       abort ();
  1269. #else
  1270.     status = commands[i].pid;
  1271. #endif
  1272.  
  1273.     if (status != 0)
  1274.       {
  1275.         int j;
  1276.         for (j = 0; j < n_commands; j++)
  1277.           if (commands[j].pid == pid)
  1278.         prog = commands[j].prog;
  1279.  
  1280.         if ((status & 0x7F) != 0)
  1281.           fatal ("Program %s got fatal signal %d.", prog, (status & 0x7F));
  1282.         if (((status & 0xFF00) >> 8) >= MIN_FATAL_STATUS)
  1283.           ret_code = -1;
  1284.       }
  1285.       }
  1286.     return ret_code;
  1287.   }
  1288. }
  1289.  
  1290. /* Find all the switches given to us
  1291.    and make a vector describing them.
  1292.    The elements of the vector a strings, one per switch given.
  1293.    If a switch uses the following argument, then the `part1' field
  1294.    is the switch itself and the `part2' field is the following argument.
  1295.    The `valid' field is nonzero if any spec has looked at this switch;
  1296.    if it remains zero at the end of the run, it must be meaningless.  */
  1297.  
  1298. struct switchstr
  1299. {
  1300.   char *part1;
  1301.   char *part2;
  1302.   int valid;
  1303. };
  1304.  
  1305. struct switchstr *switches;
  1306.  
  1307. int n_switches;
  1308.  
  1309. /* Also a vector of input files specified.  */
  1310.  
  1311. char **infiles;
  1312.  
  1313. int n_infiles;
  1314.  
  1315. /* And a vector of corresponding output files is made up later.  */
  1316.  
  1317. char **outfiles;
  1318.  
  1319. /* Create the vector `switches' and its contents.
  1320.    Store its length in `n_switches'.  */
  1321.  
  1322. void
  1323. process_command (argc, argv)
  1324.     int argc;
  1325.     char **argv;
  1326. {
  1327.     extern char *getenv ();
  1328.     register int i;
  1329.  
  1330. #if defined( DSP56000 ) || defined( DSP96000 )
  1331.     int len;
  1332.     char *string;
  1333. #endif
  1334.  
  1335.     n_switches = 0;
  1336.     n_infiles = 0;
  1337.  
  1338. #if defined( DSP56000 )
  1339.     env_exec_prefix = getenv ("G56_EXEC_PREFIX");
  1340. #endif
  1341.  
  1342. #if defined( DSP96000 )
  1343.     env_exec_prefix = getenv ("G96_EXEC_PREFIX");
  1344. #endif
  1345.  
  1346. #if !defined( DSP56000 ) && ! defined( DSP96000 )
  1347.     env_exec_prefix = getenv ("GCC_EXEC_PREFIX");
  1348. #endif
  1349.  
  1350.     /* Scan argv twice.  Here, the first time, just count how many switches
  1351.        there will be in their vector, and how many input files in theirs.
  1352.        Here we also parse the switches that cc itself uses (e.g. -v).  */
  1353.  
  1354.     for (i = 1; i < argc; i++)
  1355.     {
  1356.     if (argv[i][0] == '-' && argv[i][1] != 'l' )
  1357.     {
  1358.         register char *p = &argv[i][1];
  1359.         register int c = *p;
  1360.  
  1361.         switch (c)
  1362.         {
  1363.         case 'b':
  1364.         machine_suffix = p + 1;
  1365.         break;
  1366.  
  1367.         case 'B':
  1368.         user_exec_prefix = p + 1;
  1369.         break;
  1370.  
  1371.         case 'v':    /* Print our subcommands and print versions.  */
  1372.         vflag++;
  1373.         n_switches++;
  1374.         break;
  1375.  
  1376.         default:
  1377.         n_switches++;
  1378.      
  1379.         if (SWITCH_TAKES_ARG (c) && p[1] == 0)
  1380.             i++;
  1381.  
  1382.         else if (WORD_SWITCH_TAKES_ARG (p))
  1383.             i++;
  1384.         }
  1385.     }
  1386.  
  1387. #if defined( DSP56000 ) || defined( DSP96000 )
  1388.         else if ( (argv[i][0] == '-') && (argv[i][1] == 'l') )
  1389.     {
  1390.         n_switches++;
  1391.  
  1392.         /* pass absolute path stuff through */
  1393.         if ( argv[i][2] != PATH_DELIMITER )
  1394.         {
  1395.         len = strlen( argv[i] ) + 6;
  1396.         string = (char *) xmalloc ( len );
  1397.  
  1398.         sprintf( string,"lib%s.clb", argv[i]+2 );
  1399.         string = find_file( string );
  1400.         len = strlen( string ) + 5;
  1401.         argv[i] = (char*) xmalloc( len );
  1402.  
  1403.         sprintf( argv[i], "-L%s", string );
  1404.         free( string );
  1405.         }
  1406.     }
  1407.  
  1408. #endif /* DSP */
  1409.  
  1410.     else
  1411.     {
  1412.         n_infiles++;
  1413.     }
  1414.     }
  1415.  
  1416.     /* Then create the space for the vectors and scan again.  */
  1417.  
  1418.     switches = ((struct switchstr *)
  1419.         xmalloc ((n_switches + 1) * sizeof (struct switchstr)));
  1420.     infiles = (char **) xmalloc ((n_infiles + 1) * sizeof (char *));
  1421.     n_switches = 0;
  1422.     n_infiles = 0;
  1423.  
  1424.     /* This, time, copy the text of each switch and store a pointer
  1425.        to the copy in the vector of switches.
  1426.        Store all the infiles in their vector.  */
  1427.  
  1428.     for (i = 1; i < argc; i++)
  1429.     {
  1430.     if (argv[i][0] == '-' && argv[i][1] != 'l')
  1431.     {
  1432.         register char *p = &argv[i][1];
  1433.         register int c = *p;
  1434.  
  1435.         if (c == 'B' || c == 'b')
  1436.         continue;
  1437.  
  1438.         switches[n_switches].part1 = p;
  1439.  
  1440.         if ((SWITCH_TAKES_ARG (c) && p[1] == 0)
  1441.         || WORD_SWITCH_TAKES_ARG (p))
  1442.         switches[n_switches].part2 = argv[++i];
  1443.         else
  1444.         switches[n_switches].part2 = 0;
  1445.  
  1446.         switches[n_switches].valid = 0;
  1447.         n_switches++;
  1448.     }
  1449.  
  1450.     else
  1451.         infiles[n_infiles++] = argv[i];
  1452.     }
  1453.  
  1454.     switches[n_switches].part1 = 0;
  1455.     infiles[n_infiles] = 0;
  1456. }
  1457.  
  1458. /* Process a spec string, accumulating and running commands.  */
  1459.  
  1460. /* These variables describe the input file name.
  1461.    input_file_number is the index on outfiles of this file,
  1462.    so that the output file name can be stored for later use by %o.
  1463.    input_basename is the start of the part of the input file
  1464.    sans all directory names, and basename_length is the number
  1465.    of characters starting there excluding the suffix .c or whatever.  */
  1466.  
  1467. char *input_filename;
  1468. int input_file_number;
  1469. int input_filename_length;
  1470. int basename_length;
  1471. char *input_basename;
  1472.  
  1473. /* These are variables used within do_spec and do_spec_1.  */
  1474.  
  1475. /* Nonzero if an arg has been started and not yet terminated
  1476.    (with space, tab or newline).  */
  1477. int arg_going;
  1478.  
  1479. /* Nonzero means %d or %g has been seen; the next arg to be terminated
  1480.    is a temporary file name.  */
  1481. int delete_this_arg;
  1482.  
  1483. /* Nonzero means %w has been seen; the next arg to be terminated
  1484.    is the output file name of this compilation.  */
  1485. int this_is_output_file;
  1486.  
  1487. /* Nonzero means %s has been seen; the next arg to be terminated
  1488.    is the name of a library file and we should try the standard
  1489.    search dirs for it.  */
  1490. int this_is_library_file;
  1491.  
  1492. /* Process the spec SPEC and run the commands specified therein.
  1493.    Returns 0 if the spec is successfully processed; -1 if failed.  */
  1494.  
  1495. int
  1496. do_spec (spec)
  1497.      char *spec;
  1498. {
  1499.   int value;
  1500.  
  1501.   clear_args ();
  1502.   arg_going = 0;
  1503.   delete_this_arg = 0;
  1504.   this_is_output_file = 0;
  1505.   this_is_library_file = 0;
  1506.  
  1507.   value = do_spec_1 (spec, 0);
  1508.  
  1509.   /* Force out any unfinished command.
  1510.      If -pipe, this forces out the last command if it ended in `|'.  */
  1511.   if (value == 0)
  1512.     {
  1513.       if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
  1514.     argbuf_index--;
  1515.  
  1516.       if (argbuf_index > 0)
  1517.     value = execute ();
  1518.     }
  1519.  
  1520.   return value;
  1521. }
  1522.  
  1523. /* Process the sub-spec SPEC as a portion of a larger spec.
  1524.    This is like processing a whole spec except that we do
  1525.    not initialize at the beginning and we do not supply a
  1526.    newline by default at the end.
  1527.    INSWITCH nonzero means don't process %-sequences in SPEC;
  1528.    in this case, % is treated as an ordinary character.
  1529.    This is used while substituting switches.
  1530.    INSWITCH nonzero also causes SPC not to terminate an argument.
  1531.  
  1532.    Value is zero unless a line was finished
  1533.    and the command on that line reported an error.  */
  1534.  
  1535. int
  1536. do_spec_1 (spec, inswitch)
  1537.      char *spec;
  1538.      int inswitch;
  1539. {
  1540.   register char *p = spec;
  1541.   register int c;
  1542.   char *string;
  1543.  
  1544.   while (c = *p++)
  1545.     /* If substituting a switch, treat all chars like letters.
  1546.        Otherwise, NL, SPC, TAB and % are special.  */
  1547.     switch (inswitch ? 'a' : c)
  1548.       {
  1549.       case '\n':
  1550.     /* End of line: finish any pending argument,
  1551.        then run the pending command if one has been started.  */
  1552.     if (arg_going)
  1553.       {
  1554.         obstack_1grow (&obstack, 0);
  1555.         string = obstack_finish (&obstack);
  1556.         if (this_is_library_file)
  1557.           string = find_file (string);
  1558.         store_arg (string, delete_this_arg, this_is_output_file);
  1559.         if (this_is_output_file)
  1560.           outfiles[input_file_number] = string;
  1561.       }
  1562.     arg_going = 0;
  1563.  
  1564.     if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
  1565.       {
  1566.         int i;
  1567.         for (i = 0; i < n_switches; i++)
  1568.           if (!strcmp (switches[i].part1, "pipe"))
  1569.         break;
  1570.  
  1571.         /* A `|' before the newline means use a pipe here,
  1572.            but only if -pipe was specified.
  1573.            Otherwise, execute now and don't pass the `|' as an arg.  */
  1574.         if (i < n_switches)
  1575.           {
  1576.         switches[i].valid = 1;
  1577.         break;
  1578.           }
  1579.         else
  1580.           argbuf_index--;
  1581.       }
  1582.  
  1583.     if (argbuf_index > 0)
  1584.       {
  1585.         int value = execute ();
  1586.         if (value)
  1587.           return value;
  1588.       }
  1589.     /* Reinitialize for a new command, and for a new argument.  */
  1590.     clear_args ();
  1591.     arg_going = 0;
  1592.     delete_this_arg = 0;
  1593.     this_is_output_file = 0;
  1594.     this_is_library_file = 0;
  1595.     break;
  1596.  
  1597.       case '|':
  1598.     /* End any pending argument.  */
  1599.     if (arg_going)
  1600.       {
  1601.         obstack_1grow (&obstack, 0);
  1602.         string = obstack_finish (&obstack);
  1603.         if (this_is_library_file)
  1604.           string = find_file (string);
  1605.         store_arg (string, delete_this_arg, this_is_output_file);
  1606.         if (this_is_output_file)
  1607.           outfiles[input_file_number] = string;
  1608.       }
  1609.  
  1610.     /* Use pipe */
  1611.     obstack_1grow (&obstack, c);
  1612.     arg_going = 1;
  1613.     break;
  1614.  
  1615.       case '\t':
  1616.       case ' ':
  1617.     /* Space or tab ends an argument if one is pending.  */
  1618.     if (arg_going)
  1619.       {
  1620.         obstack_1grow (&obstack, 0);
  1621.         string = obstack_finish (&obstack);
  1622.         if (this_is_library_file)
  1623.           string = find_file (string);
  1624.         store_arg (string, delete_this_arg, this_is_output_file);
  1625.         if (this_is_output_file)
  1626.           outfiles[input_file_number] = string;
  1627.       }
  1628.     /* Reinitialize for a new argument.  */
  1629.     arg_going = 0;
  1630.     delete_this_arg = 0;
  1631.     this_is_output_file = 0;
  1632.     this_is_library_file = 0;
  1633.     break;
  1634.  
  1635.       case '%':
  1636.     switch (c = *p++)
  1637.       {
  1638.       case 0:
  1639.         fatal ("Invalid specification!  Bug in cc.");
  1640.  
  1641.       case 'b':
  1642.         obstack_grow (&obstack, input_basename, basename_length);
  1643.         arg_going = 1;
  1644.         break;
  1645.  
  1646.       case 'd':
  1647.         delete_this_arg = 2;
  1648.         break;
  1649.  
  1650.       case 'e':
  1651.         /* {...:%efoo} means report an error with `foo' as error message
  1652.            and don't execute any more commands for this file.  */
  1653.         {
  1654.           char *q = p;
  1655.           char *buf;
  1656.           while (*p != 0 && *p != '\n') p++;
  1657.           buf = (char *) alloca (p - q + 1);
  1658.           strncpy (buf, q, p - q);
  1659.           error ("%s", buf);
  1660.           return -1;
  1661.         }
  1662.         break;
  1663.  
  1664.       case 'g':
  1665.         obstack_grow (&obstack, temp_filename, temp_filename_length);
  1666.         delete_this_arg = 1;
  1667.         arg_going = 1;
  1668.         break;
  1669.  
  1670.       case 'i':
  1671.         obstack_grow (&obstack, input_filename, input_filename_length);
  1672.         arg_going = 1;
  1673.         break;
  1674.  
  1675.       case 'o':
  1676.         {
  1677.           register int f;
  1678.           for (f = 0; f < n_infiles; f++)
  1679.         store_arg (outfiles[f], 0, 0);
  1680.         }
  1681.         break;
  1682.  
  1683.       case 's':
  1684.         this_is_library_file = 1;
  1685.         break;
  1686.  
  1687.       case 'w':
  1688.         this_is_output_file = 1;
  1689.         break;
  1690.  
  1691. # if defined( DSP96000 ) || defined( DSP56000 )
  1692.       case 'z':
  1693.         {
  1694.            int  f, local_size;
  1695.            char flag;
  1696.  
  1697.            flag = *p++;
  1698.            f = 0;
  1699.            /* search for -o option */
  1700.            while ( switches[ f ].part1[0] != flag )
  1701.            {
  1702.               f ++ ;
  1703.            }
  1704.  
  1705.            local_size = strlen( switches[ f ].part2 );
  1706.            obstack_grow ( &obstack, switches[ f ].part2, local_size );
  1707.            arg_going = 1;
  1708.         }
  1709.         break;
  1710.  
  1711.       case 'Z':
  1712.         {
  1713.         store_arg (outfiles[0], 0, 0);
  1714.         }
  1715.         break;
  1716. # endif
  1717.  
  1718.       case '{':
  1719.         p = handle_braces (p);
  1720.         if (p == 0)
  1721.           return -1;
  1722.         break;
  1723.  
  1724.       case '%':
  1725.         obstack_1grow (&obstack, '%');
  1726.         break;
  1727.  
  1728. /*** The rest just process a certain constant string as a spec.  */
  1729.  
  1730.       case '1':
  1731.         do_spec_1 (CC1_SPEC, 0);
  1732.         break;
  1733.  
  1734.       case 'a':
  1735.         do_spec_1 (ASM_SPEC, 0);
  1736.         break;
  1737.  
  1738.       case 'c':
  1739.         do_spec_1 (SIGNED_CHAR_SPEC, 0);
  1740.         break;
  1741.  
  1742.       case 'C':
  1743.         do_spec_1 (CPP_SPEC, 0);
  1744.         break;
  1745.  
  1746.       case 'l':
  1747.         do_spec_1 (LINK_SPEC, 0);
  1748.         break;
  1749.  
  1750.       case 'L':
  1751.         do_spec_1 (LIB_SPEC, 0);
  1752.         break;
  1753.  
  1754.       case 'p':
  1755.         do_spec_1 (CPP_PREDEFINES, 0);
  1756.         break;
  1757.  
  1758.       case 'P':
  1759.         {
  1760.           char *x = (char *) alloca (strlen (CPP_PREDEFINES) * 2 + 1);
  1761.           char *buf = x;
  1762.           char *y = CPP_PREDEFINES;
  1763.  
  1764.           /* Copy all of CPP_PREDEFINES into BUF,
  1765.          but put __ after every -D and at the end of each arg,  */
  1766.           while (1)
  1767.         {
  1768.           if (! strncmp (y, "-D", 2))
  1769.             {
  1770.               *x++ = '-';
  1771.               *x++ = 'D';
  1772.               *x++ = '_';
  1773.               *x++ = '_';
  1774.               y += 2;
  1775.             }
  1776.           else if (*y == ' ' || *y == 0)
  1777.             {
  1778.               *x++ = '_';
  1779.               *x++ = '_';
  1780.               if (*y == 0)
  1781.             break;
  1782.               else
  1783.             *x++ = *y++;
  1784.             }
  1785.           else
  1786.             *x++ = *y++;
  1787.         }
  1788.           *x = 0;
  1789.  
  1790.           do_spec_1 (buf, 0);
  1791.         }
  1792.         break;
  1793.  
  1794.       case 'S':
  1795.         do_spec_1 (STARTFILE_SPEC, 0);
  1796.         break;
  1797.  
  1798.       default:
  1799.         abort ();
  1800.       }
  1801.     break;
  1802.  
  1803.       default:
  1804.     /* Ordinary character: put it into the current argument.  */
  1805.     obstack_1grow (&obstack, c);
  1806.     arg_going = 1;
  1807.       }
  1808.  
  1809.   return 0;        /* End of string */
  1810. }
  1811.  
  1812. /* Return 0 if we call do_spec_1 and that returns -1.  */
  1813.  
  1814. char *
  1815. handle_braces (p)
  1816.      register char *p;
  1817. {
  1818.   register char *q;
  1819.   char *filter;
  1820.   int pipe = 0;
  1821.   int negate = 0;
  1822.  
  1823.   if (*p == '|')
  1824.     /* A `|' after the open-brace means,
  1825.        if the test fails, output a single minus sign rather than nothing.
  1826.        This is used in %{|!pipe:...}.  */
  1827.     pipe = 1, ++p;
  1828.  
  1829.   if (*p == '!')
  1830.     /* A `!' after the open-brace negates the condition:
  1831.        succeed if the specified switch is not present.  */
  1832.     negate = 1, ++p;
  1833.  
  1834.   filter = p;
  1835.   while (*p != ':' && *p != '}') p++;
  1836.   if (*p != '}')
  1837.     {
  1838.       register int count = 1;
  1839.       q = p + 1;
  1840.       while (count > 0)
  1841.     {
  1842.       if (*q == '{')
  1843.         count++;
  1844.       else if (*q == '}')
  1845.         count--;
  1846.       else if (*q == 0)
  1847.         abort ();
  1848.       q++;
  1849.     }
  1850.     }
  1851.   else
  1852.     q = p + 1;
  1853.  
  1854.   if (p[-1] == '*' && p[0] == '}')
  1855.     {
  1856.       /* Substitute all matching switches as separate args.  */
  1857.       register int i;
  1858.       --p;
  1859.       for (i = 0; i < n_switches; i++)
  1860.     if (!strncmp (switches[i].part1, filter, p - filter))
  1861.       give_switch (i);
  1862.     }
  1863.   else
  1864.     {
  1865.       /* Test for presence of the specified switch.  */
  1866.       register int i;
  1867.       int present = 0;
  1868.  
  1869.       /* If name specified ends in *, as in {x*:...},
  1870.      check for presence of any switch name starting with x.  */
  1871.       if (p[-1] == '*')
  1872.     {
  1873.       for (i = 0; i < n_switches; i++)
  1874.         {
  1875.           if (!strncmp (switches[i].part1, filter, p - filter - 1))
  1876.         {
  1877.           switches[i].valid = 1;
  1878.           present = 1;
  1879.         }
  1880.         }
  1881.     }
  1882.       /* Otherwise, check for presence of exact name specified.  */
  1883.       else
  1884.     {
  1885.       for (i = 0; i < n_switches; i++)
  1886.         {
  1887.           if (!strncmp (switches[i].part1, filter, p - filter)
  1888.           && switches[i].part1[p - filter] == 0)
  1889.         {
  1890.           switches[i].valid = 1;
  1891.           present = 1;
  1892.           break;
  1893.         }
  1894.         }
  1895.     }
  1896.  
  1897.       /* If it is as desired (present for %{s...}, absent for %{-s...})
  1898.      then substitute either the switch or the specified
  1899.      conditional text.  */
  1900.       if (present != negate)
  1901.     {
  1902.       if (*p == '}')
  1903.         {
  1904.           give_switch (i);
  1905.         }
  1906.       else
  1907.         {
  1908.           if (do_spec_1 (save_string (p + 1, q - p - 2), 0) < 0)
  1909.         return 0;
  1910.         }
  1911.     }
  1912.       else if (pipe)
  1913.     {
  1914.       /* Here if a %{|...} conditional fails: output a minus sign,
  1915.          which means "standard output" or "standard input".  */
  1916.       do_spec_1 ("-", 0);
  1917.     }
  1918.     }
  1919.  
  1920.   return q;
  1921. }
  1922.  
  1923. /* Pass a switch to the current accumulating command
  1924.    in the same form that we received it.
  1925.    SWITCHNUM identifies the switch; it is an index into
  1926.    the vector of switches gcc received, which is `switches'.
  1927.    This cannot fail since it never finishes a command line.  */
  1928.  
  1929. void
  1930. give_switch (switchnum)
  1931.      int switchnum;
  1932. {
  1933.   do_spec_1 ("-", 0);
  1934.   do_spec_1 (switches[switchnum].part1, 1);
  1935.   do_spec_1 (" ", 0);
  1936.   if (switches[switchnum].part2 != 0)
  1937.     {
  1938.       do_spec_1 (switches[switchnum].part2, 1);
  1939.       do_spec_1 (" ", 0);
  1940.     }
  1941.   switches[switchnum].valid = 1;
  1942. }
  1943.  
  1944. /* Search for a file named NAME trying various prefixes including the
  1945.    user's -B prefix and some standard ones.
  1946.    Return the absolute pathname found.  If nothing is found, return NAME.  */
  1947.  
  1948. char *
  1949. find_file (name)
  1950.     char *name;
  1951. {
  1952.     int size;
  1953.     char *temp;
  1954.     int win = 0;
  1955.  
  1956.     /* Compute maximum size of NAME plus any prefix we will try.  */
  1957.  
  1958.     size = strlen (standard_exec_prefix);
  1959.     if (user_exec_prefix != 0 && strlen (user_exec_prefix) > size)
  1960.     size = strlen (user_exec_prefix);
  1961.     if (env_exec_prefix != 0 && strlen (env_exec_prefix) > size)
  1962.     size = strlen (env_exec_prefix);
  1963.     if (strlen (standard_exec_prefix) > size)
  1964.     size = strlen (standard_exec_prefix);
  1965.     if (strlen (standard_exec_prefix_1) > size)
  1966.     size = strlen (standard_exec_prefix_1);
  1967.     if (strlen (standard_startfile_prefix) > size)
  1968.     size = strlen (standard_startfile_prefix);
  1969.     if (strlen (standard_startfile_prefix_1) > size)
  1970.     size = strlen (standard_startfile_prefix_1);
  1971.     if (strlen (standard_startfile_prefix_2) > size)
  1972.     size = strlen (standard_startfile_prefix_2);
  1973.     if (machine_suffix)
  1974.     size += strlen (machine_suffix) + 1;
  1975.     size += strlen (name) + 1;
  1976.     
  1977.     temp = (char *) alloca (size);
  1978.  
  1979.     if (user_exec_prefix)
  1980.     {
  1981.     if (machine_suffix)
  1982.     {
  1983.         strcpy (temp, user_exec_prefix);
  1984.         strcat (temp, machine_suffix);
  1985.         strcat (temp, name);
  1986.         win = (access (temp, R_OK) == 0);
  1987.     }
  1988.  
  1989.     if (!win)
  1990.     {
  1991.         strcpy (temp, user_exec_prefix);
  1992.         strcat (temp, name);
  1993.         win = (access (temp, R_OK) == 0);
  1994.     }
  1995.     }
  1996.  
  1997.     if (!win && env_exec_prefix)
  1998.     {
  1999.     if (machine_suffix)
  2000.     {
  2001.         strcpy (temp, env_exec_prefix);
  2002.         strcat (temp, machine_suffix);
  2003.         strcat (temp, name);
  2004.         win = (access (temp, R_OK) == 0);
  2005.     }
  2006.  
  2007.     if (!win)
  2008.     {
  2009.         strcpy (temp, env_exec_prefix);
  2010.         strcat (temp, name);
  2011.         win = (access (temp, R_OK) == 0);
  2012.     }
  2013.     }
  2014.  
  2015.     if (!win)
  2016.     {
  2017.     if (machine_suffix)
  2018.     {
  2019.         strcpy (temp, standard_exec_prefix);
  2020.         strcat (temp, machine_suffix);
  2021.         strcat (temp, name);
  2022.         win = (access (temp, R_OK) == 0);
  2023.     }
  2024.  
  2025.     if (!win)
  2026.     {
  2027.         strcpy (temp, standard_exec_prefix);
  2028.         strcat (temp, name);
  2029.         win = (access (temp, R_OK) == 0);
  2030.     }
  2031.     }
  2032.  
  2033.     if (!win)
  2034.     {
  2035.     if (machine_suffix)
  2036.     {
  2037.         strcpy (temp, standard_exec_prefix_1);
  2038.         strcat (temp, machine_suffix);
  2039.         strcat (temp, name);
  2040.         win = (access (temp, R_OK) == 0);
  2041.     }
  2042.  
  2043.     if (!win)
  2044.     {
  2045.         strcpy (temp, standard_exec_prefix_1);
  2046.         strcat (temp, name);
  2047.         win = (access (temp, R_OK) == 0);
  2048.     }
  2049.     }
  2050.  
  2051.     if (!win)
  2052.     {
  2053.     if (machine_suffix)
  2054.     {
  2055.         strcpy (temp, standard_startfile_prefix);
  2056.         strcat (temp, machine_suffix);
  2057.         strcat (temp, name);
  2058.         win = (access (temp, R_OK) == 0);
  2059.     }
  2060.  
  2061.     if (!win)
  2062.     {
  2063.         strcpy (temp, standard_startfile_prefix);
  2064.         strcat (temp, name);
  2065.         win = (access (temp, R_OK) == 0);
  2066.     }
  2067.     }
  2068.  
  2069.     if (!win)
  2070.     {
  2071.     if (machine_suffix)
  2072.     {
  2073.         strcpy (temp, standard_startfile_prefix_1);
  2074.         strcat (temp, machine_suffix);
  2075.         strcat (temp, name);
  2076.         win = (access (temp, R_OK) == 0);
  2077.     }
  2078.  
  2079.     if (!win)
  2080.     {
  2081.         strcpy (temp, standard_startfile_prefix_1);
  2082.         strcat (temp, name);
  2083.         win = (access (temp, R_OK) == 0);
  2084.     }
  2085.     }
  2086.  
  2087.     if (!win)
  2088.     {
  2089.     if (machine_suffix)
  2090.     {
  2091.         strcpy (temp, standard_startfile_prefix_2);
  2092.         strcat (temp, machine_suffix);
  2093.         strcat (temp, name);
  2094.         win = (access (temp, R_OK) == 0);
  2095.     }
  2096.  
  2097.     if (!win)
  2098.     {
  2099.         strcpy (temp, standard_startfile_prefix_2);
  2100.         strcat (temp, name);
  2101.         win = (access (temp, R_OK) == 0);
  2102.     }
  2103.     }
  2104.  
  2105.     if (!win)
  2106.     {
  2107.     if (machine_suffix)
  2108.     {
  2109.         strcpy (temp, DOT_PATH);
  2110.         strcat (temp, machine_suffix);
  2111.         strcat (temp, name);
  2112.         win = (access (temp, R_OK) == 0);
  2113.     }
  2114.  
  2115.     if (!win)
  2116.     {
  2117.         strcpy (temp, DOT_PATH);
  2118.         strcat (temp, name);
  2119.         win = (access (temp, R_OK) == 0);
  2120.     }
  2121.     }
  2122.  
  2123.     if (win)
  2124.     return save_string (temp, strlen (temp));
  2125.   return name;
  2126. }
  2127.  
  2128. /* On fatal signals, delete all the temporary files.  */
  2129.  
  2130. void
  2131. fatal_error (signum)
  2132.      int signum;
  2133. {
  2134.   signal (signum, SIG_DFL);
  2135.   delete_failure_queue ();
  2136.   delete_temp_files ();
  2137.   /* Get the same signal again, this time not handled,
  2138.      so its normal effect occurs.  */
  2139. #ifndef __TURBOC__
  2140.   kill (getpid (), signum);
  2141. #endif
  2142. }
  2143.  
  2144. #if defined( DSP56000 ) || defined( DSP96000 )
  2145. char **original_argv, ***addr_of_original_argv;
  2146.  
  2147. /* value of DSPLOC environment variable */
  2148. char *dsploc = NULL;
  2149. #endif
  2150.  
  2151. int
  2152. main (argc, argv)
  2153.      int argc;
  2154.      char **argv;
  2155. {
  2156.   register int i;
  2157.   int value;
  2158.   int error_count = 0;
  2159.   int linker_was_run = 0;
  2160.   char *explicit_link_files;
  2161.  
  2162.   programname = argv[0];
  2163.  
  2164. #if defined( DSP56000 ) || defined( DSP96000 )
  2165.   {
  2166.       extern char *getenv ( );
  2167.       
  2168.       dsploc = getenv ( "DSPLOC" );
  2169.  
  2170.       if ( NULL != dsploc )
  2171.       {
  2172.       char *manip = dsploc;
  2173.       int dsploclen;
  2174.  
  2175. #if defined( _MSDOS )
  2176.       char *dirstr = "\\";
  2177. #else
  2178.       char *dirstr = "/";
  2179. #endif
  2180.       
  2181.       /* allow for growth. */
  2182.       dsploc = strcpy ( (char*) xmalloc ( strlen ( dsploc ) +
  2183.                      sizeof ( "$dsp$" )), dsploc );
  2184.       
  2185.       /* root the dsp dir at dsploc: usually /usr/local */
  2186.       while ( '\0' != ( * manip ))
  2187.       {
  2188.           ++ manip;
  2189.       }
  2190.  
  2191.       if ( dirstr[0] != ( * ( -- manip )))
  2192.       {
  2193.           strcat ( dsploc, dirstr );
  2194.       }
  2195.       strcat ( dsploc, "dsp" );
  2196.       strcat ( dsploc, dirstr );
  2197.       
  2198.       dsploclen = strlen ( dsploc );
  2199.  
  2200.       /* jam dsploc into everything that needs it */
  2201.       
  2202.       standard_exec_prefix = 
  2203.           (char*) xmalloc ( dsploclen + sizeof ( "bin" ) + 1 );
  2204.       strcpy ( standard_exec_prefix, dsploc );
  2205.       strcat ( standard_exec_prefix, "bin" );
  2206.       strcat ( standard_exec_prefix, dirstr );
  2207.  
  2208.       standard_startfile_prefix = 
  2209.           (char*) xmalloc ( dsploclen + sizeof ( "lib" ) + 1 );
  2210.       strcpy ( standard_startfile_prefix, dsploc );
  2211.       strcat ( standard_startfile_prefix, "lib" );
  2212.       strcat ( standard_startfile_prefix, dirstr );
  2213.       }
  2214.   }
  2215. #endif
  2216.  
  2217. #ifndef __TURBOC__
  2218.   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
  2219.     signal (SIGINT, fatal_error);
  2220.   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
  2221.     signal (SIGHUP, fatal_error);
  2222.   if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
  2223.     signal (SIGTERM, fatal_error);
  2224. #endif
  2225.  
  2226. #if defined( DSP56000 ) || defined( DSP96000 )
  2227.   /* the fabulous IBM-PC forces us to extend command-line lengths via files */
  2228.   original_argv = argv;
  2229.   extend_argv( &argc, &argv );
  2230.  
  2231. #if defined( _MSDOS ) && ! defined( __TURBOC__ )
  2232.   {
  2233.       void fix_original_argv( void );
  2234.       atexit( fix_original_argv );
  2235.   }
  2236. #endif
  2237. #endif
  2238.  
  2239.   argbuf_length = 10;
  2240.   argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));
  2241.  
  2242.   obstack_init (&obstack);
  2243.  
  2244.   choose_temp_base ();
  2245.   
  2246.   /* Make a table of what switches there are (switches, n_switches).
  2247.      Make a table of specified input files (infiles, n_infiles).  */
  2248.  
  2249.   process_command (argc, argv);
  2250.  
  2251.   if (vflag)
  2252.     {
  2253.       extern char *motorola_version_string;
  2254.       extern char *version_string;
  2255.  
  2256. #if defined( DSP56000 )
  2257.       fprintf (stderr, "g56k version %s -- GNU %s\n", motorola_version_string, version_string);
  2258. #endif
  2259.  
  2260. #if defined( DSP96000 )
  2261.       fprintf (stderr, "g96k version %s -- GNU %s\n", motorola_version_string, version_string);
  2262. #endif
  2263.  
  2264. #if !defined( DSP56000 ) && !defined( DSP96000 )
  2265.       fprintf (stderr, "gcc version %s\n", version_string);
  2266. #endif
  2267.  
  2268.       if (n_infiles == 0)
  2269.     exit (0);
  2270.     }
  2271.  
  2272.   if (n_infiles == 0)
  2273.     fatal ("No input files specified.");
  2274.  
  2275.   /* Make a place to record the compiler output file names
  2276.      that correspond to the input files.  */
  2277.  
  2278.   outfiles = (char **) xmalloc (n_infiles * sizeof (char *));
  2279.   bzero (outfiles, n_infiles * sizeof (char *));
  2280.  
  2281.   /* Record which files were specified explicitly as link input.  */
  2282.  
  2283.   explicit_link_files = (char *) xmalloc (n_infiles);
  2284.   bzero (explicit_link_files, n_infiles);
  2285.  
  2286.   for (i = 0; i < n_infiles; i++)
  2287.     {
  2288.       register struct compiler *cp;
  2289.       int this_file_error = 0;
  2290.  
  2291.       /* Tell do_spec what to substitute for %i.  */
  2292.  
  2293.       input_filename = infiles[i];
  2294.       input_filename_length = strlen (input_filename);
  2295.       input_file_number = i;
  2296.  
  2297.       /* Use the same thing in %o, unless cp->spec says otherwise.  */
  2298.  
  2299.       outfiles[i] = input_filename;
  2300.  
  2301.       /* Figure out which compiler from the file's suffix.  */
  2302.  
  2303.       for (cp = compilers; cp->spec; cp++)
  2304.     {
  2305.       if (strlen (cp->suffix) < input_filename_length
  2306.           && !strcmp (cp->suffix,
  2307.               infiles[i] + input_filename_length
  2308.               - strlen (cp->suffix)))
  2309.         {
  2310.           /* Ok, we found an applicable compiler.  Run its spec.  */
  2311.           /* First say how much of input_filename to substitute for %b  */
  2312.           register char *p;
  2313.  
  2314.           input_basename = input_filename;
  2315.           for (p = input_filename; *p; p++)
  2316.         if (*p == '/')
  2317.           input_basename = p + 1;
  2318.           basename_length = (input_filename_length - strlen (cp->suffix)
  2319.                  - (input_basename - input_filename));
  2320.           value = do_spec (cp->spec);
  2321.           if (value < 0)
  2322.         this_file_error = 1;
  2323.           break;
  2324.         }
  2325.     }
  2326.  
  2327.       /* If this file's name does not contain a recognized suffix,
  2328.      record it as explicit linker input.  */
  2329.  
  2330.       if (! cp->spec)
  2331.     explicit_link_files[i] = 1;
  2332.  
  2333.       /* Clear the delete-on-failure queue, deleting the files in it
  2334.      if this compilation failed.  */
  2335.  
  2336.       if (this_file_error)
  2337.     {
  2338.       delete_failure_queue ();
  2339.       error_count++;
  2340.     }
  2341.       /* If this compilation succeeded, don't delete those files later.  */
  2342.       clear_failure_queue ();
  2343.     }
  2344.  
  2345.   /* Run ld to link all the compiler output files.  */
  2346.  
  2347.   if (error_count == 0)
  2348.     {
  2349.       int tmp = execution_count;
  2350.       value = do_spec (link_spec);
  2351.       if (value < 0)
  2352.     error_count = 1;
  2353.       linker_was_run = (tmp != execution_count);
  2354.     }
  2355.  
  2356.   /* If options said don't run linker,
  2357.      complain about input files to be given to the linker.  */
  2358.  
  2359.   if (! linker_was_run && error_count == 0)
  2360.     for (i = 0; i < n_infiles; i++)
  2361.       if (explicit_link_files[i])
  2362.     error ("%s: linker input file unused since linking not done",
  2363.            outfiles[i]);
  2364.  
  2365.   /* Set the `valid' bits for switches that match anything in any spec.  */
  2366.  
  2367.   validate_all_switches ();
  2368.  
  2369.   /* Warn about any switches that no pass was interested in.  */
  2370.   
  2371.   for (i = 0; i < n_switches; i++)
  2372.     if (! switches[i].valid)
  2373.       error ("unrecognized option `-%s'", switches[i].part1);
  2374.  
  2375.   /* Delete some or all of the temporary files we made.  */
  2376.  
  2377.   if (error_count)
  2378.     delete_failure_queue ();
  2379.   delete_temp_files ();
  2380.  
  2381.   exit (error_count);
  2382. }
  2383.  
  2384. #if defined( _MSDOS )
  2385. void*
  2386. xmalloc (size)
  2387.      int size;
  2388. {
  2389.   register void *value = malloc (size);
  2390.   if (value == NULL)
  2391.     fatal ("Virtual memory full.");
  2392.   return value;
  2393. }
  2394.  
  2395. void*
  2396. xrealloc (ptr, size)
  2397.     void *ptr;
  2398.     int size;
  2399. {
  2400.   register void *value = realloc (ptr, size);
  2401.   if (value == NULL)
  2402.     fatal ("Virtual memory full.");
  2403.   return value;
  2404. }
  2405. #else
  2406. int
  2407. xmalloc (size)
  2408.      int size;
  2409. {
  2410. #if defined( NeXT )
  2411.   int value = (int) malloc ((size_t)size);
  2412. #else
  2413.   register int value = malloc (size);
  2414. #endif
  2415.   if (value == 0)
  2416.     fatal ("Virtual memory full.");
  2417.   return value;
  2418. }
  2419.  
  2420. int
  2421. xrealloc (ptr, size)
  2422.      int ptr, size;
  2423. {
  2424. #if defined( NeXT )
  2425.   int value = (int) realloc ((void*)ptr, (size_t)size);
  2426. #else
  2427.   register int value = realloc (ptr, size);
  2428. #endif
  2429.   if (value == 0)
  2430.     fatal ("Virtual memory full.");
  2431.   return value;
  2432. }
  2433. #endif
  2434.  
  2435. /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3.  */
  2436.  
  2437. char *
  2438. concat (s1, s2, s3)
  2439.      char *s1, *s2, *s3;
  2440. {
  2441.   int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
  2442.   char *result = (char *) xmalloc (len1 + len2 + len3 + 1);
  2443.  
  2444.   strcpy (result, s1);
  2445.   strcpy (result + len1, s2);
  2446.   strcpy (result + len1 + len2, s3);
  2447.   *(result + len1 + len2 + len3) = 0;
  2448.  
  2449.   return result;
  2450. }
  2451.  
  2452. char *
  2453. save_string (s, len)
  2454.      char *s;
  2455.      int len;
  2456. {
  2457.   register char *result = (char *) xmalloc (len + 1);
  2458.  
  2459.   bcopy (s, result, len);
  2460.   result[len] = 0;
  2461.   return result;
  2462. }
  2463.  
  2464. void
  2465. pfatal_with_name (name)
  2466.      char *name;
  2467. {
  2468.   extern int errno, sys_nerr;
  2469.   extern char *sys_errlist[];
  2470.   char *s;
  2471.  
  2472.   if (errno < sys_nerr)
  2473.     s = concat ("%s: ", sys_errlist[errno], "");
  2474.   else
  2475.     s = "cannot open %s";
  2476.   fatal (s, name);
  2477. }
  2478.  
  2479. void
  2480. perror_with_name (name)
  2481.      char *name;
  2482. {
  2483.   extern int errno, sys_nerr;
  2484.   extern char *sys_errlist[];
  2485.   char *s;
  2486.  
  2487.   if (errno < sys_nerr)
  2488.     s = concat ("%s: ", sys_errlist[errno], "");
  2489.   else
  2490.     s = "cannot open %s";
  2491.   error (s, name);
  2492. }
  2493.  
  2494. void
  2495. perror_exec (name)
  2496.      char *name;
  2497. {
  2498.   extern int errno, sys_nerr;
  2499.   extern char *sys_errlist[];
  2500.   char *s;
  2501.  
  2502.   if (errno < sys_nerr)
  2503.     s = concat ("installation problem, cannot exec %s: ",
  2504.         sys_errlist[errno], "");
  2505.   else
  2506.     s = "installation problem, cannot exec %s";
  2507.   error (s, name);
  2508. }
  2509.  
  2510. /* More 'friendly' abort that prints the line and file.
  2511.    config.h can #define abort fancy_abort if you like that sort of thing.  */
  2512.  
  2513. void
  2514. fancy_abort ()
  2515. {
  2516.   fatal ("Internal gcc abort.");
  2517. }
  2518.  
  2519. #ifdef HAVE_VPRINTF
  2520.  
  2521. /* Output an error message and exit */
  2522.  
  2523. int 
  2524. fatal (va_alist)
  2525.      va_dcl
  2526. {
  2527.   va_list ap;
  2528.   char *format;
  2529.   
  2530.   va_start(ap);
  2531.   format = va_arg (ap, char *);
  2532.   vfprintf (stderr, format, ap);
  2533.   va_end (ap);
  2534.   fprintf (stderr, "\n");
  2535.   delete_temp_files (0);
  2536.   exit (1);
  2537. }  
  2538.  
  2539. void
  2540. error (va_alist) 
  2541.      va_dcl
  2542. {
  2543.   va_list ap;
  2544.   char *format;
  2545.  
  2546.   va_start(ap);
  2547.   format = va_arg (ap, char *);
  2548.   fprintf (stderr, "%s: ", programname);
  2549.   vfprintf (stderr, format, ap);
  2550.   va_end (ap);
  2551.  
  2552.   fprintf (stderr, "\n");
  2553. }
  2554.  
  2555. #else /* not HAVE_VPRINTF */
  2556. void
  2557. fatal (msg, arg1, arg2)
  2558.      char *msg, *arg1, *arg2;
  2559. {
  2560.   error (msg, arg1, arg2);
  2561.   delete_temp_files (0);
  2562.   exit (1);
  2563. }
  2564.  
  2565. void
  2566. error (msg, arg1, arg2)
  2567.      char *msg, *arg1, *arg2;
  2568. {
  2569.   fprintf (stderr, "%s: ", programname);
  2570.   fprintf (stderr, msg, arg1, arg2);
  2571.   fprintf (stderr, "\n");
  2572. }
  2573.  
  2574. #endif /* not HAVE_VPRINTF */
  2575.  
  2576.  
  2577. void
  2578. validate_all_switches ()
  2579. {
  2580.   struct compiler *comp;
  2581.   register char *p;
  2582.   register char c;
  2583.  
  2584.   for (comp = compilers; comp->spec; comp++)
  2585.     {
  2586.       p = comp->spec;
  2587.       while (c = *p++)
  2588.     if (c == '%' && *p == '{')
  2589.       /* We have a switch spec.  */
  2590.       validate_switches (p + 1);
  2591.     }
  2592.  
  2593.   p = link_spec;
  2594.   while (c = *p++)
  2595.     if (c == '%' && *p == '{')
  2596.       /* We have a switch spec.  */
  2597.       validate_switches (p + 1);
  2598.  
  2599.   /* Now notice switches mentioned in the machine-specific specs.  */
  2600.  
  2601. #ifdef ASM_SPEC
  2602.   p = ASM_SPEC;
  2603.   while (c = *p++)
  2604.     if (c == '%' && *p == '{')
  2605.       /* We have a switch spec.  */
  2606.       validate_switches (p + 1);
  2607. #endif
  2608.  
  2609. #ifdef CPP_SPEC
  2610.   p = CPP_SPEC;
  2611.   while (c = *p++)
  2612.     if (c == '%' && *p == '{')
  2613.       /* We have a switch spec.  */
  2614.       validate_switches (p + 1);
  2615. #endif
  2616.  
  2617. #ifdef SIGNED_CHAR_SPEC
  2618.   p = SIGNED_CHAR_SPEC;
  2619.   while (c = *p++)
  2620.     if (c == '%' && *p == '{')
  2621.       /* We have a switch spec.  */
  2622.       validate_switches (p + 1);
  2623. #endif
  2624.  
  2625. #ifdef CC1_SPEC
  2626.   p = CC1_SPEC;
  2627.   while (c = *p++)
  2628.     if (c == '%' && *p == '{')
  2629.       /* We have a switch spec.  */
  2630.       validate_switches (p + 1);
  2631. #endif
  2632.  
  2633. #ifdef LINK_SPEC
  2634.   p = LINK_SPEC;
  2635.   while (c = *p++)
  2636.     if (c == '%' && *p == '{')
  2637.       /* We have a switch spec.  */
  2638.       validate_switches (p + 1);
  2639. #endif
  2640.  
  2641. #ifdef LIB_SPEC
  2642.   p = LIB_SPEC;
  2643.   while (c = *p++)
  2644.     if (c == '%' && *p == '{')
  2645.       /* We have a switch spec.  */
  2646.       validate_switches (p + 1);
  2647. #endif
  2648.  
  2649. #ifdef STARTFILE_SPEC
  2650.   p = STARTFILE_SPEC;
  2651.   while (c = *p++)
  2652.     if (c == '%' && *p == '{')
  2653.       /* We have a switch spec.  */
  2654.       validate_switches (p + 1);
  2655. #endif
  2656. }
  2657.  
  2658. /* Look at the switch-name that comes after START
  2659.    and mark as valid all supplied switches that match it.  */
  2660.  
  2661. void
  2662. validate_switches (start)
  2663.      char *start;
  2664. {
  2665.   register char *p = start;
  2666.   char *filter;
  2667.   register int i;
  2668.  
  2669.   if (*p == '|')
  2670.     ++p;
  2671.  
  2672.   if (*p == '!')
  2673.     ++p;
  2674.  
  2675.   filter = p;
  2676.   while (*p != ':' && *p != '}') p++;
  2677.  
  2678.   if (p[-1] == '*')
  2679.     {
  2680.       /* Mark all matching switches as valid.  */
  2681.       --p;
  2682.       for (i = 0; i < n_switches; i++)
  2683.     if (!strncmp (switches[i].part1, filter, p - filter))
  2684.       switches[i].valid = 1;
  2685.     }
  2686.   else
  2687.     {
  2688.       /* Mark an exact matching switch as valid.  */
  2689.       for (i = 0; i < n_switches; i++)
  2690.     {
  2691.       if (!strncmp (switches[i].part1, filter, p - filter)
  2692.           && switches[i].part1[p - filter] == 0)
  2693.         switches[i].valid = 1;
  2694.     }
  2695.     }
  2696. }
  2697.  
  2698.  
  2699. #if defined( _MSDOS )
  2700. int
  2701. bcopy ( b1, b2, length )
  2702.     char* b1, * b2;
  2703.     int length;
  2704. {
  2705.     if (( b1 < b2 ) && (( b1 + length ) > b2 ))
  2706.     {
  2707.     b2 += ( length - 1 );
  2708.     b1 += ( length - 1 );
  2709.     while ( length -- )
  2710.         *b2-- = *b1--;
  2711.     }
  2712.     else
  2713.     {
  2714.     while ( length -- )
  2715.         *b2++ = *b1++;
  2716.     }
  2717.     return 0;
  2718. }
  2719.  
  2720. int
  2721. bzero ( b, length )
  2722.     char* b;
  2723.     int length;
  2724. {
  2725.     while ( length -- )
  2726.     *b++ = 0;
  2727.  
  2728.     return 0;
  2729. }
  2730. #endif
  2731.  
  2732. #if defined( _MSDOS ) && ( defined( DSP56000 ) || defined( DSP96000 ))
  2733. void
  2734. fix_original_argv(void)
  2735. {
  2736.     /* restore original argv */
  2737.     *addr_of_original_argv = original_argv;
  2738. }
  2739. #endif
  2740.